C++ ++ 和 -- 运算符重载

递增运算符（ ++ ）和递减运算符（ -- ）是 C++ 语言中两个重要的一元运算符。

下面的实例演示了如何重载递增运算符（ ++ ），包括前缀和后缀两种用法。类似地，您也可以尝试重载递减运算符（ -- ）。

      #include <iostream>
      using namespace std;

      class Time
      {
         private:
            int hours;             // 0 到 23
            int minutes;           // 0 到 59
         public:
            // 所需的构造函数
            Time(){
               hours = 0;
               minutes = 0;
            }
            Time(int h, int m){
               hours = h;
               minutes = m;
            }
            // 显示时间的方法
            void displayTime()
            {
               cout << "H: " << hours << " M:" << minutes <<endl;
            }
            // 重载前缀递增运算符（ ++ ）
            Time operator++ ()  
            {
               ++minutes;          // 对象加 1
               if(minutes >= 60)  
               {
                  ++hours;
                  minutes -= 60;
               }
               return Time(hours, minutes);
            }
            // 重载后缀递增运算符（ ++ ）
            Time operator++( int )         
            {
               // 保存原始值
               Time T(hours, minutes);
               // 对象加 1
               ++minutes;                    
               if(minutes >= 60)
               {
                  ++hours;
                  minutes -= 60;
               }
               // 返回旧的原始值
               return T; 
            }
      };
      int main()
      {
         Time T1(11, 59), T2(10,40);

         ++T1;                    // T1 加 1
         T1.displayTime();        // 显示 T1
         ++T1;                    // T1 再加 1
         T1.displayTime();        // 显示 T1

         T2++;                    // T2 加 1
         T2.displayTime();        // 显示 T2
         T2++;                    // T2 再加 1
         T2.displayTime();        // 显示 T2
         return 0;
      }

当上面的代码被编译和执行时，它会产生下列结果：

      H: 12 M:0
      H: 12 M:1
      H: 10 M:41
      H: 10 M:42

递增和递减运算符重载 1、递增和递减一般是改变对象的状态，所以一般是重载为成员函数。

2、重载递增递减，一定要和指针的递增递减区分开。因为这里的重载操作的是对象，而不是指针(由于指针是内置类型，指针的递增递减是无法重载的)，所以一般情况的递增递减是操作对象内部的成员变量。

3、递增和递减分为前置和后置情况，a = ++b;(前置)， a = b++;(后置)。因为符号一样，所以给后置版本加一个int形参作为区分，这个形参是0，但是在函数体中是用不到的，只是为了区分前置后置。例如：

      #include <stdio.h>
      #include <stdlib.h>
      #include <string>
      #include <iostream>

      using namespace std;

      // 例如这里的重载递增就是为了增加pos的值
      class ca
      {
      public:    
          int pos;

          //前置递增就是增加当前对象的pos的值，并且返回当前对象
          ca operator++(){
              pos++;
              return *this;
          }

          //后置递增就是增加当前对象的pos的值，并且返回增加pos之前的该对象
          ca operator++(int){
              ca ret = *this;
              ++*this;        //这个会调用上面的函数，其实这里可以换成pos++;
              return ret;
          }
      };

      int main()
      {
          ca a, b;

          a.pos = 1;

          b = a++;
          cout << "b1:" << b.pos << endl;   // b1:1

          b = ++a;
          cout << "b2:" << b.pos << endl;   // b1:3

          return 0;
      }

输出结果:

      b1:1
      b2:3

🔚